{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### J. Xia, L. Bombrun, T. Adalı, Y. Berthoumieu and C. Germain, Spectral–Spatial Classification of Hyperspectral Images Using ICA and Edge-Preserving Filter via an Ensemble Strategy, *IEEE Transactions on Geoscience and Remote Sensing*, vol. 54, no. 8, pp. 4971-4982, Aug. 2016."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import scipy.io as scio\n",
    "import matlab\n",
    "import matlab.engine\n",
    "import scipy.misc\n",
    "from tqdm import tqdm,trange\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "from rotation_forest import RotationTreeClassifier, RotationForestClassifier\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "engine = matlab.engine.start_matlab()#启动matlab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:No traceback has been produced, nothing to debug.\n"
     ]
    }
   ],
   "source": [
    "%debug"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Loading and producting dataset**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load dataset(indian_pines & pavia_univ.)\n",
    "def load_data(flag):\n",
    "    if flag=='indian':\n",
    "        Ind_pines_dict=scio.loadmat('Indian_pines.mat')\n",
    "        Ind_pines_gt_dict=scio.loadmat('Indian_pines_gt.mat')\n",
    "\n",
    "        print(Ind_pines_dict['indian_pines'].shape)\n",
    "        print(Ind_pines_gt_dict['indian_pines_gt'].shape)\n",
    "\n",
    "        original=Ind_pines_dict['indian_pines'].reshape(145*145,220)\n",
    "        gt=Ind_pines_gt_dict['indian_pines_gt'].reshape(145*145,1)\n",
    "        \n",
    "        r=Ind_pines_dict['indian_pines'].shape[0]\n",
    "        c=Ind_pines_dict['indian_pines'].shape[1]\n",
    "        categories=17\n",
    "    if flag=='pavia':\n",
    "        pav_univ_dict=scio.loadmat('paviaU.mat')\n",
    "        pav_univ_gt_dict=scio.loadmat('paviaU_gt.mat')\n",
    "        \n",
    "        print(pav_univ_dict['paviaU'].shape)\n",
    "        print(pav_univ_gt_dict['paviaU_gt'].shape)\n",
    "        \n",
    "        original=pav_univ_dict['paviaU'].reshape(610*340,103)\n",
    "        gt=pav_univ_gt_dict['paviaU_gt'].reshape(610*340,1)\n",
    "        \n",
    "        r=pav_univ_dict['paviaU'].shape[0]\n",
    "        c=pav_univ_dict['paviaU'].shape[1]\n",
    "        categories=10\n",
    "        \n",
    "    rows=np.arange(gt.shape[0])#从0开始\n",
    "    #行号(ID)，特征数据，类别号\n",
    "    All_data=np.c_[rows,original,gt]\n",
    "    \n",
    "    #剔除非0类别，获取所有labeled数据\n",
    "    labeled_data=All_data[All_data[:,-1]!=0,:]\n",
    "    rows_num=labeled_data[:,0]#所有labeled数据的ID\n",
    "    \n",
    "    return All_data,labeled_data,rows_num,categories,r,c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(610, 340, 103)\n",
      "(610, 340)\n",
      "Data has been loaded successfully!\n"
     ]
    }
   ],
   "source": [
    "#load dataset(indian_pines & pavia_univ.)\n",
    "###### indian or pavia\n",
    "All_data,labeled_data,rows_num,categories,r,c=load_data(flag='pavia')\n",
    "print('Data has been loaded successfully!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Step 1 RS ensemble (E):**    \n",
    "The number of subsets is set to $K$, and $M$ features in each subset are randomly selected without replacement from original spectral bands\n",
    "论文中$K$=10，$M$=number of classes, 全图特征分割而非训练集测试集分割"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "##无放回抽样(selected without replacement)\n",
    "def sampling(All_data,categories):\n",
    "    K=10\n",
    "    M=categories-1\n",
    "    origin=All_data[:,1:-1]\n",
    "    bands=np.arange(origin.shape[1])\n",
    "    ensumb_num={}#波段号\n",
    "    ensumb_feature_set={}\n",
    "    for i in range(K):\n",
    "        ensumb_num[str(i+1)]=np.random.choice(bands,M,replace=False)\n",
    "        idx=[j for j in range(len(bands)) if bands[j] in ensumb_num[str(i+1)]]\n",
    "        bands=np.delete(bands,idx)#删除idx处的值\n",
    "    for i in range(K):\n",
    "        ensumb_feature_set[str(i+1)]=origin[:,ensumb_num[str(i+1)]]\n",
    "    return ensumb_feature_set,K,M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RS ensumble Finished!\n"
     ]
    }
   ],
   "source": [
    "#sampling\n",
    "ensumb_feature_set,K,M=sampling(All_data,categories)\n",
    "print('RS ensumble Finished!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Step 2 ICA:**  \n",
    "The aim of this step is to extract informative ICs for the classes in each subset, to be used for classification. Here, we propose to use EBM and ERBM due to their superior separation performance，在全图分割的特征子集上进行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ICA(ensumb_feature_set,K):\n",
    "    #A=np.random.rand(ensumb_feature_set['1'].shape[0],ensumb_feature_set['1'].shape[0])\n",
    "    ensumb_ICAEBM={}\n",
    "    for i in tqdm(range(K)):\n",
    "        data_list=ensumb_feature_set[str(i+1)].T.tolist()\n",
    "        rr=ensumb_feature_set[str(i+1)].shape[0]\n",
    "        cc=ensumb_feature_set[str(i+1)].shape[1]\n",
    "        #print(ensumb_feature_set[str(i+1)].shape)\n",
    "        W1=engine.ICA_EBM(matlab.double(data_list),cc,rr)#调用ICA_EBM算法,X=As,s=WX,W=A^-1,16*16\n",
    "        #print(type(W1))\n",
    "        ensumb_ICAEBM[str(i+1)]=np.dot(W1,ensumb_feature_set[str(i+1)].T)#(16,16)*(16,2w)\n",
    "    return ensumb_ICAEBM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████| 10/10 [05:23<00:00, 28.61s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ICA Finished!\n"
     ]
    }
   ],
   "source": [
    "#ICA\n",
    "#engine = matlab.engine.start_matlab(\"-desktop\")#matlab GUI\n",
    "ensumb_ICAEBM=ICA(ensumb_feature_set,K)\n",
    "print('ICA Finished!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Step 3 RGF:**   \n",
    "RGF is performed on each extracted component to obtain the mth feature in the ith subset. Thus\n",
    "$$G_k^m \\leftarrow \\text{Algorithm 1} (IC_k^m,\\sigma_s,\\sigma_r,n^{iter})$$\n",
    "where $\\sigma_s$ and $\\sigma_r$ are the spatial and range standard deviations of the filter in . \n",
    "$$J^{t+1}(i)=\\frac{1}{Q_i}\\sum\\limits_{j\\in \\mathcal{N}_p}\\exp\\left(-\\frac{||i-j||^2}{2\\sigma_s^2}-\\frac{||J^t(i)-J^t(j)||^2}{2\\sigma_r^2}\\right)I(j)$$ $$Q_i=\\sum\\limits_{j\\in \\mathcal{N}_p}\\exp\\left(-\\frac{||i-j||^2}{2\\sigma_s^2}-\\frac{||J^t(i)-J^t(j)||^2}{2\\sigma_r^2}\\right)$$\n",
    "$IC_k^m$ is the $m$th $(m = 1,\\cdots,M)$ component derived from ICA in the $k$th $(k = 1,\\cdots,K)$ subset. $G_k^m$ is the resulting feature obtained after RGF."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RGF(ensumb_ICAEBM,K,r,c):\n",
    "    ensumb_RGF={}\n",
    "    #for i in range(K):\n",
    "        #ensumb_ICAEBM[str(i+1)]=(ensumb_ICAEBM[str(i+1)]-np.min(ensumb_ICAEBM[str(i+1)]))/(np.max(ensumb_ICAEBM[str(i+1)])-np.min(ensumb_ICAEBM[str(i+1)]))\n",
    "    for i in tqdm(range(K)):\n",
    "        z=ensumb_ICAEBM[str(i+1)].shape[0]\n",
    "        img=ensumb_ICAEBM[str(i+1)].T.reshape(r,c,z)#img-2D to 3D\n",
    "        datalist=img.tolist()\n",
    "        #scio.savemat(\"dataNew.mat\", {'I': ensumb_ICAEBM[str(i+1)].T})\n",
    "        img_RGF=engine.RollingGuidanceFilter(matlab.double(datalist),r,c,z,7,0.1,5)#img-3D,sigma_s,sigma_r,n_iter\n",
    "        img_RGF=np.array(img_RGF)\n",
    "        ensumb_RGF[str(i+1)]=img_RGF.reshape(r*c,z)#img-2D\n",
    "    return ensumb_RGF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████| 10/10 [05:14<00:00, 31.15s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RGF Finished!\n"
     ]
    }
   ],
   "source": [
    "#RGF\n",
    "ensumb_RGF=RGF(ensumb_ICAEBM,K,r,c)\n",
    "print('RGF Finished!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generating training and testing number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#product the training and testing dataset\n",
    "def generation_num(labeled_data,rows_num,categories):\n",
    "    \n",
    "    train_num=[]\n",
    "    \n",
    "    for i in range(1,categories):\n",
    "        temp=labeled_data[labeled_data[:,-1]==i,:]\n",
    "        temp_num=temp[:,0]#某类别的所有ID\n",
    "        np.random.shuffle(temp_num)#打乱顺序\n",
    "        if temp.shape[0]<30:\n",
    "            train_num.append(temp_num[0:int(temp.shape[0]/2)])\n",
    "        else:\n",
    "            train_num.append(temp_num[0:30])\n",
    "            \n",
    "    trn_num = [x for j in train_num for x in j]#合并list中各元素\n",
    "    tes_num=list(set(rows_num)-set(trn_num))\n",
    "    return rows_num,trn_num,tes_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random number generated Finished!\n"
     ]
    }
   ],
   "source": [
    "#generating random number\n",
    "rows_num,trn_num,tes_num=generation_num(labeled_data,rows_num,categories)\n",
    "print('Random number generated Finished!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Parallel combination (P):**  \n",
    "- Step 4  \n",
    "Perform classification on the filtered images in each subset. Two classifiers (e.g., RF and RoF) are used. For RoF, the feature space is randomly split into several subsets. Then, PCA is applied on each subset. Furthermore, new training data are formed by concatenating all the principal components in each subset. An individual decision tree classifier is trained with this training set. A series of individual classifiers is generated by repeating the above steps several times. The final classification result is produced by integrating the results from individual classifiers using a majority-vote rule [13], [27], [41]. For both RF and RoF, two parameters, i.e., the number of trees and the number of selected features, are empirically fixed. According to the study presented in [16], the number of trees of the RF and RoF classifiers is set to 100 and 20, respectively. Moreover, the number of selected features isset to$\\sqrt{M}$  \n",
    "- Step 5:     \n",
    "Combine the results together to generate the final classification map by a majority-vote rule. The rule considered when combining the results of the single classifiers relies on the sumof the votes of the classifiers applied to the features obtained from ICA and RGF, assigning each pixel to a class.  \n",
    "\n",
    "#### **Concatenated combination (C)**  \n",
    "- Step 4: Concatenate the features together.  \n",
    "- Step 5: Perform classification on the concatenated features\n",
    "to produce the final result (the same with step 4 of parallel\n",
    "combination)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Random Forest，论文中分类器个数取100，selected feature=$\\sqrt{M}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "##RF\n",
    "def RF_voting(ensumb_trn,y_trn,ensumb_tes,y_tes,K):\n",
    "    RF_model={}\n",
    "    RF_oob=np.zeros([K])\n",
    "    for i in range(K):\n",
    "        RF_model[str(i+1)]=RandomForestClassifier(oob_score=True,n_estimators=100,random_state=None,max_features='sqrt')#sqrt(M)\n",
    "        RF_model[str(i+1)].fit(ensumb_trn[str(i+1)],y_trn)\n",
    "        RF_oob[i]=RF_model[str(i+1)].oob_score\n",
    "    y_pre_mat_RF=np.zeros([y_tes.shape[0],10]).astype(int)\n",
    "    y_pre_RF=np.zeros([y_tes.shape[0]])\n",
    "    for i in range(K):\n",
    "        y_pre_mat_RF[:,i]=RF_model[str(i+1)].predict(ensumb_tes[str(i+1)])\n",
    "    #print(type(y_pre_mat_RF[0,0]))\n",
    "    ######## Step 5:voting #############\n",
    "    for j in range(y_tes.shape[0]):\n",
    "        y_pre_RF[j]=np.argmax(np.bincount(y_pre_mat_RF[j,:]))#bincount:数组a的元素作为index，相应数量作为value，长度为max(a)+1(从0开始) \n",
    "    return y_pre_RF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rotation Forest，论文中分类器个数取20，selected feature=$\\sqrt{M}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "##RoF\n",
    "def RoF_voting(ensumb_trn,y_trn,ensumb_tes,y_tes,K,M):\n",
    "    RoF_model={}\n",
    "    RoF_oob=np.zeros([K])\n",
    "    sel_feat=int(np.sqrt(M))\n",
    "    for i in range(K):\n",
    "        RoF_model[str(i+1)]=RotationForestClassifier(n_estimators=20,random_state=None,max_features=sel_feat)#sqrt(M)\n",
    "        RoF_model[str(i+1)].fit(ensumb_trn[str(i+1)],y_trn)\n",
    "    y_pre_mat_RoF=np.zeros([y_tes.shape[0],10]).astype(int)\n",
    "    y_pre_RoF=np.zeros([y_tes.shape[0]])\n",
    "    for i in range(K):\n",
    "        y_pre_mat_RoF[:,i]=RoF_model[str(i+1)].predict(ensumb_tes[str(i+1)])\n",
    "    ######## Step 5:voting #############\n",
    "    for j in range(y_tes.shape[0]):\n",
    "        y_pre_RoF[j]=np.argmax(np.bincount(y_pre_mat_RoF[j,:]))#bincount:数组a的元素作为index，相应数量作为value，长度为max(a)+1(从0开始) \n",
    "    return y_pre_RoF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parallel combination (P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Parallel_combination(All_data,ensumb_RGF,trn_num,tes_num,K,classifier,M):\n",
    "    ensumb_trn={}\n",
    "    ensumb_tes={}\n",
    "    #生成训练集/测试集\n",
    "    for j in range(K):\n",
    "        ensumb_trn[str(j+1)]=ensumb_RGF[str(j+1)][trn_num,:]\n",
    "        ensumb_tes[str(j+1)]=ensumb_RGF[str(j+1)][tes_num,:]\n",
    "    y_trn=All_data[trn_num,-1]\n",
    "    y_tes=All_data[tes_num,-1]\n",
    "    print(ensumb_trn['1'].shape)\n",
    "    print(y_trn.shape)\n",
    "    print(ensumb_tes['1'].shape)\n",
    "    print(y_tes.shape)\n",
    "    if classifier=='RF':\n",
    "        y_pre_P=RF_voting(ensumb_trn,y_trn,ensumb_tes,y_tes,K)\n",
    "    if classifier=='RoF':\n",
    "        y_pre_P=RoF_voting(ensumb_trn,y_trn,ensumb_tes,y_tes,K,M)\n",
    "    return y_pre_P,y_tes,y_trn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "##RF\n",
    "def RF_overall(X_trn,y_trn,X_tes):\n",
    "    RF_model=RandomForestClassifier(oob_score=True,n_estimators=100,random_state=None,max_features='sqrt')#sqrt(c)\n",
    "    RF_model.fit(X_trn,y_trn)\n",
    "    RF_oob=RF_model.oob_score\n",
    "    ######## Step 5:Classificaton #############\n",
    "    y_pre_RF=RF_model.predict(X_tes)\n",
    "    return y_pre_RF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "##RoF\n",
    "def RoF_overall(X_trn,y_trn,X_tes):\n",
    "    sel_feat=int(np.sqrt(X_trn.shape[1]))\n",
    "    RoF_model=RotationForestClassifier(n_estimators=20,random_state=None,max_features=sel_feat)#sqrt(c)\n",
    "    RoF_model.fit(X_trn,y_trn)\n",
    "    ######## Step 5:Classificaton #############\n",
    "    y_pre_RoF=RoF_model.predict(X_tes)\n",
    "    return y_pre_RoF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenated combination (C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Concatenated_combination(All_data,ensumb_RGF,trn_num,tes_num,K,classifier):\n",
    "    for i in range(K):\n",
    "        if i==0:\n",
    "            X_RGF=ensumb_RGF[str(i+1)]\n",
    "        else:\n",
    "            X_RGF=np.c_[X_RGF,ensumb_RGF[str(i+1)]]\n",
    "    X_trn=X_RGF[trn_num,:]\n",
    "    X_tes=X_RGF[tes_num,:]\n",
    "    y_trn=All_data[trn_num,-1]\n",
    "    y_tes=All_data[tes_num,-1]\n",
    "    print(X_trn.shape)\n",
    "    print(y_trn.shape)\n",
    "    print(X_tes.shape)\n",
    "    print(y_tes.shape)\n",
    "    if classifier=='RF':\n",
    "        y_pre_C=RF_overall(X_trn,y_trn,X_tes)\n",
    "    if classifier=='RoF':\n",
    "        y_pre_C=RoF_overall(X_trn,y_trn,X_tes)\n",
    "    return y_pre_C,y_tes,y_trn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classification(All_data,ensumb_RGF,trn_num,tes_num,K,strategy,classifier,M):\n",
    "    if strategy=='Parallel':\n",
    "        y_pre,y_tes,y_trn=Parallel_combination(All_data,ensumb_RGF,trn_num,tes_num,K,classifier,M)\n",
    "    if strategy=='concatenated':\n",
    "        y_pre,y_tes,y_trn=Concatenated_combination(All_data,ensumb_RGF,trn_num,tes_num,K,classifier)\n",
    "    return y_pre,y_tes,y_trn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Main Program**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(270, 9)\n",
      "(270,)\n",
      "(42506, 9)\n",
      "(42506,)\n",
      "Classifying Finished!\n"
     ]
    }
   ],
   "source": [
    "#Classifing\n",
    "######strategy: Parallel or concatenated\n",
    "######classifier: RF or RoF\n",
    "y_pre,y_tes,y_trn=classification(All_data,ensumb_RGF,trn_num,tes_num,K,'Parallel','RF',M)\n",
    "print('Classifying Finished!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(270, 9)\n",
      "(270,)\n",
      "(42506, 9)\n",
      "(42506,)\n",
      "Classifying Finished!\n"
     ]
    }
   ],
   "source": [
    "#Classifing\n",
    "######strategy: Parallel or concatenated\n",
    "######classifier: RF or RoF\n",
    "y_pre_rof,y_tes_rof,y_trn=classification(All_data,ensumb_RGF,trn_num,tes_num,K,'Parallel','RoF',M)\n",
    "print('Classifying Finished!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking Overall Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9790617795134805\n"
     ]
    }
   ],
   "source": [
    "OA=np.mean(y_pre==y_tes)\n",
    "print(OA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9810614972003953\n"
     ]
    }
   ],
   "source": [
    "OA_rof=np.mean(y_pre_rof==y_tes_rof)\n",
    "print(OA_rof)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9876017503411283\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(y_pre==y_pre_rof))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(y_tes==y_tes_rof))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Displaying Classification Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_disp=np.zeros([All_data.shape[0]])\n",
    "y_disp[trn_num]=y_trn\n",
    "y_disp[tes_num]=y_pre\n",
    "\n",
    "y_disp_rof=y_disp.copy()\n",
    "y_disp_rof[tes_num]=y_pre_rof\n",
    "\n",
    "y_disp_gt=y_disp.copy()\n",
    "y_disp_gt[tes_num]=y_tes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Export *.mat for MATLAB to produce image(Because PIL lacked...)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "scio.savemat(\"pavia_gt\", {'gt':y_disp_gt.reshape(r,c)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parallel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplots(figsize=[12,10])\n",
    "ax1=plt.subplot(1,3,1)\n",
    "plt.xlabel('E-ICA-RGF_RF(P)')\n",
    "a1=plt.imshow(y_disp.reshape(r,c),cmap='jet')\n",
    "plt.xticks([])\n",
    "plt.yticks([])\n",
    "#divider = make_axes_locatable(ax1)\n",
    "#cax1 = divider.append_axes(\"right\", size=\"1%\", pad=0.05)\n",
    "\n",
    "ax2=plt.subplot(1,3,2)\n",
    "plt.xlabel('E-ICA-RGF_RoF(P)')\n",
    "a2=plt.imshow(y_disp_rof.reshape(r,c),cmap='jet')\n",
    "plt.xticks([])\n",
    "plt.yticks([])\n",
    "#divider = make_axes_locatable(ax1)\n",
    "#cax1 = divider.append_axes(\"right\", size=\"1%\", pad=0.05)\n",
    "\n",
    "ax3=plt.subplot(1,3,3)\n",
    "a3=plt.imshow(y_disp_gt.reshape(r,c),cmap='jet')\n",
    "plt.xticks([])\n",
    "plt.yticks([])\n",
    "plt.xlabel('Ground Truth')\n",
    "#divider = make_axes_locatable(ax2)\n",
    "#cax2 = divider.append_axes(\"right\", size=\"1%\", pad=0.05)\n",
    "plt.subplots_adjust(bottom=0.1, right=0.8, top=0.45,hspace=0,wspace=0)\n",
    "cax = plt.axes([0.8, 0.1, 0.03, 0.35])\n",
    "plt.colorbar(cax=cax)\n",
    "plt.savefig(\"pavia_P.png\",dpi=600,bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplots(figsize=[12,10])\n",
    "ax1=plt.subplot(1,3,1)\n",
    "plt.xlabel('E-ICA-RGF_RF(C)')\n",
    "a1=plt.imshow(y_disp.reshape(r,c),cmap='jet')\n",
    "plt.xticks([])\n",
    "plt.yticks([])\n",
    "#divider = make_axes_locatable(ax1)\n",
    "#cax1 = divider.append_axes(\"right\", size=\"1%\", pad=0.05)\n",
    "\n",
    "ax2=plt.subplot(1,3,2)\n",
    "plt.xlabel('E-ICA-RGF_RoF(C)')\n",
    "a2=plt.imshow(y_disp_rof.reshape(r,c),cmap='jet')\n",
    "plt.xticks([])\n",
    "plt.yticks([])\n",
    "#divider = make_axes_locatable(ax1)\n",
    "#cax1 = divider.append_axes(\"right\", size=\"1%\", pad=0.05)\n",
    "\n",
    "ax3=plt.subplot(1,3,3)\n",
    "a3=plt.imshow(y_disp_gt.reshape(r,c),cmap='jet')\n",
    "plt.xticks([])\n",
    "plt.yticks([])\n",
    "plt.xlabel('Ground Truth')\n",
    "#divider = make_axes_locatable(ax2)\n",
    "#cax2 = divider.append_axes(\"right\", size=\"1%\", pad=0.05)\n",
    "plt.subplots_adjust(bottom=0.1, right=0.8, top=0.45,hspace=0,wspace=0)\n",
    "cax = plt.axes([0.8, 0.1, 0.03, 0.35])\n",
    "plt.colorbar(cax=cax)\n",
    "plt.savefig(\"pavia_C.png\",dpi=600,bbox_inches='tight')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python py35matlab17b",
   "language": "python",
   "name": "py4matlab"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
